home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / formats / iff / newiff.lzh / NewIFF / NewIFF.lzh / newiff / apps / ILBMDemo / ILBMDemo.c < prev   
C/C++ Source or Header  |  1992-05-18  |  10KB  |  411 lines
  1. /* ILBMDemo.c  05/91   C. Scheppner CBM
  2.  *
  3.  * Demonstrates displaying an ILBM, loading a brush,
  4.  *   saving an ILBM, and optionally printing a screen (CTRL-p)
  5.  *   Use -c (or -c1, -c2, etc) as filename to read from or save to clipboard.
  6.  *
  7.  * requires linkage with several iffp modules - see Makefile
  8.  */
  9. #define INTUI_V36_NAMES_ONLY
  10.  
  11. #include "iffp/ilbmapp.h"
  12.  
  13. #ifdef LATTICE
  14. int CXBRK(void) { return(0); }  /* Disable Lattice CTRL/C handling */
  15. int chkabort(void) { return(0); }  /* really */
  16. #endif
  17.  
  18. void chkmsg(void);
  19. void cleanup(void);
  20. void bye(UBYTE *s,int error);
  21.  
  22. #define SAVECHANGES
  23.  
  24. #define MINARGS 3
  25. char *vers = "$VER: ILBMDemo 37.9";
  26. char *Copyright = "ILBMDemo v37.9 (Freely Redistributable)";
  27. char *usage =
  28. "Usage: ILBMDemo sourceilbm destilbm [brushname]  (CTRL-p to print screen)\n"
  29. "Displays source, optionally loads and blits brush, saves to dest\n"
  30. "Use filename -c[unit] (ie. -c, -c1, -c2, etc.) for clipboard\n";
  31.  
  32. char *savename;
  33.  
  34. struct Library *IntuitionBase  = NULL;
  35. struct Library *GfxBase        = NULL;
  36. struct Library *IFFParseBase   = NULL;
  37.  
  38. /* Note - these fields are also available in the ILBMInfo structure */
  39. struct   Screen         *scr;         /* for ptr to screen structure */
  40. struct   Window         *win;         /* for ptr to window structure */
  41. struct   RastPort       *wrp;         /* for ptr to RastPort  */
  42. struct   ViewPort       *vp;          /* for ptr to Viewport  */
  43.  
  44. struct   IntuiMessage   *msg;
  45.  
  46. struct   NewWindow      mynw = {
  47.    0, 0,                                  /* LeftEdge and TopEdge */
  48.    0, 0,                                /* Width and Height */
  49.    -1, -1,                                /* DetailPen and BlockPen */
  50.    IDCMP_VANILLAKEY | IDCMP_MOUSEBUTTONS, /* IDCMP Flags with Flags below */
  51.    WFLG_BACKDROP | WFLG_BORDERLESS |
  52.    WFLG_SMART_REFRESH | WFLG_NOCAREREFRESH |
  53.    WFLG_ACTIVATE | WFLG_RMBTRAP,
  54.    NULL, NULL,                            /* Gadget and Image pointers */
  55.    NULL,                                  /* Title string */
  56.    NULL,                                  /* Screen ptr null till opened */
  57.    NULL,                                  /* BitMap pointer */
  58.    50, 20,                                /* MinWidth and MinHeight */
  59.    0 , 0,                                 /* MaxWidth and MaxHeight */
  60.    CUSTOMSCREEN                           /* Type of window */
  61.    };
  62.  
  63.  
  64. BOOL   FromWb, Done;
  65.  
  66.  
  67. /* ILBM Property chunks to be grabbed
  68.  * List BMHD, CMAP and CAMG first so we can skip them when we write
  69.  * the file back out (they will be written out with separate code)
  70.  */
  71. LONG    ilbmprops[] = {
  72.         ID_ILBM, ID_BMHD,
  73.         ID_ILBM, ID_CMAP,
  74.         ID_ILBM, ID_CAMG,
  75.         ID_ILBM, ID_CCRT,
  76.         ID_ILBM, ID_AUTH,
  77.         ID_ILBM, ID_Copyright,
  78.         TAG_DONE
  79.         };
  80.  
  81. /* ILBM Collection chunks (more than one in file) to be gathered */
  82. LONG    ilbmcollects[] = {
  83.         ID_ILBM, ID_CRNG,
  84.         TAG_DONE
  85.         };
  86.  
  87. /* ILBM Chunk to stop on */
  88. LONG    ilbmstops[] = {
  89.         ID_ILBM, ID_BODY,
  90.         TAG_DONE
  91.         };
  92.  
  93.  
  94. /* For test of adding new chunks to saved FORM */
  95. struct Chunk newchunks[2] = {
  96.     {
  97.     &newchunks[1],
  98.     ID_ILBM, ID_AUTH, IFFSIZE_UNKNOWN,
  99.     "CAS_CBM"},
  100.     {
  101.     NULL,
  102.     ID_ILBM, ID_NAME, IFFSIZE_UNKNOWN,
  103.     "Untitled No. 27"},
  104.     };
  105.  
  106.  
  107. UBYTE nomem[]  = "Not enough memory\n";
  108. UBYTE noiffh[] = "Can't alloc iff\n";
  109.  
  110. /* our indexes to reference our frames
  111.  * DEFault, BRUsh, and SCReen
  112.  */
  113. #define DEF    0
  114. #define BRU    1
  115. #define SCR    2
  116. #define UICOUNT 3
  117.  
  118. /* For our ILBM frames */
  119. struct ILBMInfo  *ilbms[UICOUNT]  = { NULL };
  120.  
  121.  
  122. /* 
  123.  * MAIN 
  124.  */
  125. void main(int argc, char **argv)
  126.    {
  127. #ifdef SAVECHANGES
  128.    struct Chunk *chunk;
  129.    CamgChunk *camg;
  130.    LONG saverror;
  131. #endif
  132.    UBYTE *ilbmname=NULL, *brushname=NULL, ans, c;
  133.    BPTR lock;
  134.    LONG error;
  135.  
  136.    FromWb = argc ? FALSE : TRUE;
  137.  
  138.    if((argc<MINARGS)||(argv[argc-1][0]=='?'))
  139.     {
  140.     printf("%s\n%s\n",Copyright,usage);
  141.         bye("",RETURN_OK);
  142.     }
  143.  
  144.    switch(argc)
  145.       {
  146.       case 4:
  147.          brushname    = argv[3];
  148.       case 3:
  149.          savename    = argv[2];
  150.          ilbmname    = argv[1];
  151.          break;
  152.       }
  153.  
  154.    /* if dest not clipboard, warn if dest file already exists */
  155.    if(strcmp(savename,"-c"))
  156.     {
  157.     if(lock = Lock(savename,ACCESS_READ))
  158.         {
  159.         UnLock(lock);
  160.         printf("Dest file \"%s\" already exists.  Overwrite (y or n) ? ",
  161.             savename);
  162.         ans = 0;
  163.         while((c = getchar()) != '\n') if(!ans)  ans = c | 0x20;
  164.         if(ans == 'n')   bye("Exiting.\n",RETURN_OK);
  165.         }
  166.     }
  167.         
  168.    /* Open Libraries */
  169.  
  170.    if(!(IntuitionBase = OpenLibrary("intuition.library", 0)))
  171.       bye("Can't open intuition library.\n",RETURN_WARN);
  172.       
  173.    if(!(GfxBase = OpenLibrary("graphics.library",0)))
  174.       bye("Can't open graphics library.\n",RETURN_WARN);
  175.  
  176.    if(!(IFFParseBase = OpenLibrary("iffparse.library",0)))
  177.       bye("Can't open iffparse library.\n",RETURN_WARN);
  178.  
  179.  
  180.  
  181. /* 
  182.  * Alloc three ILBMInfo structs (one each for defaults, screen, brush) 
  183.  */
  184.     if(!(ilbms[0] = (struct ILBMInfo *)
  185.     AllocMem(UICOUNT * sizeof(struct ILBMInfo),MEMF_PUBLIC|MEMF_CLEAR))) 
  186.         bye(nomem,RETURN_FAIL);
  187.     else 
  188.     {
  189.     ilbms[BRU] = ilbms[0] + 1;
  190.     ilbms[SCR] = ilbms[0] + 2;
  191.     }
  192.  
  193. /*
  194.  * Here we set up default ILBMInfo fields for our
  195.  * application's frames.
  196.  * Above we have defined the propery and collection chunks
  197.  * we are interested in (some required like BMHD)
  198.  * Since all of our frames are for ILBM's, we'll initialize
  199.  * one default frame and clone the others from it.
  200.  */
  201.     ilbms[DEF]->ParseInfo.propchks    = ilbmprops;
  202.     ilbms[DEF]->ParseInfo.collectchks    = ilbmcollects;
  203.     ilbms[DEF]->ParseInfo.stopchks    = ilbmstops;
  204.  
  205.     ilbms[DEF]->windef    = &mynw;
  206. /* 
  207.  * Initialize our working ILBM frames from our default one
  208.  */
  209.     *ilbms[SCR] = *ilbms[DEF];    /* for our screen */
  210.     *ilbms[BRU] = *ilbms[DEF];    /* for our brush  */
  211.  
  212. /* 
  213.  * Alloc two IFF handles (one for screen frame, one for brush frame) 
  214.  */
  215.     if(!(ilbms[SCR]->ParseInfo.iff = AllocIFF())) bye(noiffh,RETURN_FAIL);
  216.     if(!(ilbms[BRU]->ParseInfo.iff = AllocIFF())) bye(noiffh,RETURN_FAIL);
  217.  
  218. /* Load and display an ILBM
  219.  */
  220.     if(error = showilbm(ilbms[SCR],ilbmname))
  221.     {
  222.     printf("Can't load background \"%s\"\n",ilbmname);
  223.     bye("",RETURN_WARN);
  224.     }
  225.  
  226.     /* These were set up by our successful showilbm() above */
  227.     win = ilbms[SCR]->win;    /* our window */
  228.     wrp = ilbms[SCR]->wrp;    /* our window's RastPort */
  229.     scr = ilbms[SCR]->scr;    /* our screen */
  230.     vp  = ilbms[SCR]->vp;        /* our screen's ViewPort */
  231.  
  232.     ScreenToFront(scr);
  233.  
  234.  
  235.  /* Now let's load a brush and blit it into the window
  236.   */
  237.     if(brushname)
  238.     {
  239.     if (error = loadbrush(ilbms[BRU],brushname))
  240.         {
  241.         printf("Can't load brush \"%s\"\n",brushname);
  242.         bye("",RETURN_WARN);
  243.         }
  244.     else    /* Success */
  245.         {
  246.         D(bug("About to Blt bitmap $%lx to rp $%lx, w=%ld h=%ld\n",
  247.         ilbms[BRU]->brbitmap,wrp,ilbms[BRU]->Bmhd.w,ilbms[BRU]->Bmhd.h));
  248.             BltBitMapRastPort(ilbms[BRU]->brbitmap,0,0,
  249.                              wrp,0,0,
  250.                              ilbms[BRU]->Bmhd.w, ilbms[BRU]->Bmhd.h,
  251.                              0xC0);
  252.              }
  253.     }
  254.  
  255. #ifdef SAVECHANGES
  256.  
  257.  /* This code is an example for Read/Modify/Write programs
  258.   *
  259.   * We copy off the parsed chunks we want to preserve,
  260.   * close the IFF read file, reopen it for write,
  261.   * and save a new ILBM which
  262.   * will include the chunks we have preserved, but
  263.   * with newly computed and set-up BMHD, CMAP, and CAMG.
  264.   */ 
  265.  
  266.    if(!(ilbms[SCR]->ParseInfo.copiedchunks =
  267.     copychunks(ilbms[SCR]->ParseInfo.iff,
  268.            ilbmprops, ilbmcollects,
  269.            MEMF_PUBLIC)))
  270.         printf("error cloning chunks\n");
  271.    else
  272.     {
  273.         /* we can close the file now */
  274.        closeifile(ilbms[SCR]);
  275.  
  276.        printf("Test of copychunks and findchunk:\n");
  277.  
  278.        /* Find copied CAMG chunk if any */
  279.        if(chunk = findchunk(ilbms[SCR]->ParseInfo.copiedchunks,ID_ILBM,ID_CAMG))
  280.         {
  281.         camg = (CamgChunk *)chunk->ch_Data;
  282.         printf("CAMG: $%08lx\n",camg->ViewModes);
  283.         }
  284.         else printf("No CAMG found\n");
  285.  
  286.        /* Find copied CRNG chunks if any */
  287.        if(chunk = findchunk(ilbms[SCR]->ParseInfo.copiedchunks,ID_ILBM,ID_CRNG))
  288.         {
  289.            while((chunk)&&(chunk->ch_ID == ID_CRNG))
  290.         {
  291.         printf("Found a CRNG chunk\n");
  292.         chunk = chunk->ch_Next;
  293.         }
  294.         }
  295.        else printf("No CRNG chunks found\n");
  296.     }
  297.  
  298.     printf("\nAbout to save screen as %s, adding NAME and AUTH chunks\n",
  299.         savename);
  300.  
  301.     if(saverror = screensave(ilbms[SCR], ilbms[SCR]->scr,
  302.                 ilbms[SCR]->ParseInfo.copiedchunks,
  303.                 newchunks,
  304.                 savename))
  305.             printf("%s\n",IFFerr(saverror));
  306.  
  307. #endif
  308.  
  309.    Done = FALSE;
  310.    while(!Done)
  311.       {
  312.       Wait(1<<win->UserPort->mp_SigBit);
  313.       chkmsg();
  314.       }
  315.  
  316.  
  317.    cleanup();
  318.    exit(RETURN_OK);
  319.    }
  320.  
  321.  
  322. void chkmsg(void)
  323.     {
  324.     LONG  error;
  325.     ULONG class;
  326.     UWORD code;
  327.     WORD  mousex, mousey;
  328.  
  329.     while(msg = (struct IntuiMessage *)GetMsg(win->UserPort))
  330.     {
  331.     class = msg->Class;
  332.           code  = msg->Code;
  333.           mousex = msg->MouseX;
  334.           mousey = msg->MouseY;
  335.  
  336.           ReplyMsg(msg);
  337.           switch(class)
  338.            {
  339.         case IDCMP_MOUSEBUTTONS:
  340.         switch(code)
  341.         {
  342.         /* emulate a close gadget */
  343.         case SELECTDOWN:
  344.            if((mousex < 12)&&(mousey < 12))    Done = TRUE;
  345.            break;
  346.         default:
  347.            break;
  348.         }
  349.             case IDCMP_VANILLAKEY:
  350.             switch(code)
  351.                    {
  352.         /* also quit on CTRL-C, CTRL-D, or q */
  353.                    case 'q': case 0x04: case 0x03:
  354.                   Done = TRUE;
  355.                   break;
  356.         case 0x10:    /* CTRL-p means print */
  357.  
  358.           /* Print the whole screen */
  359.           if(error=screendump(ilbms[SCR]->scr,
  360.                 0,0,
  361.                 ilbms[SCR]->scr->Width,
  362.                 ilbms[SCR]->scr->Height,
  363.                 0,0))
  364.             printf("Screendump printer error=%ld\n",error);
  365.           break;
  366.             
  367.                    default:
  368.                   break;
  369.         }
  370.             default:
  371.             break;
  372.             }
  373.           }
  374.     }
  375.  
  376.  
  377. void bye(UBYTE *s,int error)
  378.    {
  379.    if((*s)&&(!FromWb)) printf("%s\n",s);
  380.    cleanup();
  381.    exit(error);
  382.    }
  383.  
  384.  
  385. void cleanup()
  386.    {
  387.    if(ilbms[SCR])
  388.     {
  389.        if(ilbms[SCR]->scr)        unshowilbm(ilbms[SCR]);
  390. #ifdef SAVECHANGES
  391.        freechunklist(ilbms[SCR]->ParseInfo.copiedchunks);
  392. #endif
  393.        if(ilbms[SCR]->ParseInfo.iff)    FreeIFF(ilbms[SCR]->ParseInfo.iff);
  394.     }
  395.  
  396.    if(ilbms[BRU])
  397.     {
  398.        if(ilbms[BRU]->brbitmap)    unloadbrush(ilbms[BRU]);
  399.        if(ilbms[BRU]->ParseInfo.iff)     FreeIFF(ilbms[BRU]->ParseInfo.iff);
  400.     }
  401.  
  402.    if(ilbms[0])
  403.     {
  404.     FreeMem(ilbms[0],UICOUNT * sizeof(struct ILBMInfo));
  405.     }
  406.  
  407.    if(GfxBase)          CloseLibrary(GfxBase);
  408.    if(IntuitionBase) CloseLibrary(IntuitionBase);
  409.    if(IFFParseBase)  CloseLibrary(IFFParseBase);
  410.    }
  411.